const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const { spawn } = require('child_process');
const fs = require('fs');
const serve = require('electron-serve');

let backendProcess;

// 设置前端资源服务
const loadURL = serve({ directory: path.join(__dirname, 'frontend', 'dist') });

// 检查是否在生产环境（打包后的应用）
const isProduction = app.isPackaged || process.execPath.includes('win-unpacked');

// 检查并安装后端依赖
function installBackendDependencies() {
  // 在生产环境中，后端文件在 resources/backend 目录中
  const backendPath = isProduction 
    ? path.join(process.resourcesPath, 'backend')
    : path.join(__dirname, 'backend');
  const installScriptPath = path.join(backendPath, 'install.js');
  
  if (fs.existsSync(installScriptPath)) {
    try {
      // 使用 Electron 的 Node.js 可执行文件路径
      const nodePath = process.execPath;
      // 使用完整的绝对路径来执行安装脚本
      const installProcess = spawn(nodePath, [installScriptPath], { 
        cwd: backendPath,
        stdio: 'inherit'
      });
      
      installProcess.on('close', (code) => {
        if (code === 0) {
          console.log('Backend dependencies check completed successfully');
        } else {
          console.error(`Backend dependencies check failed with code ${code}`);
        }
      });
    } catch (error) {
      console.error('Failed to run backend dependency check:', error);
    }
  } else {
    console.log('Backend install script not found, skipping dependency check');
  }
}

// 启动后端服务
function startBackend() {
  // 在生产环境中，后端文件在 resources/backend 目录中
  const backendPath = isProduction 
    ? path.join(process.resourcesPath, 'backend')
    : path.join(__dirname, 'backend');
  // 检查 start.js 文件是否存在
  const startScriptPath = path.join(backendPath, 'start.js');
  
  if (fs.existsSync(startScriptPath)) {
    // 使用 Electron 的 Node.js 可执行文件路径
    const nodePath = process.execPath;
    // 使用完整的绝对路径来启动 start.js
    backendProcess = spawn(nodePath, [startScriptPath], { cwd: backendPath });
    
    backendProcess.stdout.on('data', (data) => {
      console.log(`Backend: ${data}`);
    });
    
    backendProcess.stderr.on('data', (data) => {
      console.error(`Backend Error: ${data}`);
    });
    
    backendProcess.on('close', (code) => {
      console.log(`Backend process exited with code ${code}`);
    });
  } else {
    console.error('Backend start.js not found at:', startScriptPath);
  }
}

// 创建浏览器窗口
const createWindow = () => {
  const mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    titleBarStyle: 'hidden', // 隐藏标题栏内容但保留控制按钮
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js')
    }
  });

  // 在生产环境中，使用 electron-serve 加载前端文件
  if (isProduction) {
    // 检查并安装后端依赖
    installBackendDependencies();
    
    // 启动后端服务
    setTimeout(() => {
      startBackend();
      
      // 等待后端服务启动后再加载前端页面
      setTimeout(() => {
        // 使用 electron-serve 加载前端文件
        loadURL(mainWindow);
      }, 3000);
    }, 2000);
  } else {
    // 在开发环境中，检查前端构建文件是否存在
    const frontendDistPath = path.join(__dirname, 'frontend', 'dist');
    if (fs.existsSync(frontendDistPath)) {
      // 检查并安装后端依赖
      installBackendDependencies();
      
      // 启动后端服务
      setTimeout(() => {
        startBackend();
        
        // 等待后端服务启动后再加载前端页面
        setTimeout(() => {
          // 使用 electron-serve 加载前端文件
          loadURL(mainWindow);
        }, 3000);
      }, 2000);
    } else {
      // 在开发环境中，启动前端开发服务器
      const frontendPath = path.join(__dirname, 'frontend');
      const frontendProcess = spawn('npm', ['run', 'serve'], { 
        cwd: frontendPath,
        shell: true
      });
      
      frontendProcess.stdout.on('data', (data) => {
        console.log(`Frontend: ${data}`);
        // 当前端服务器启动后，加载前端页面
        if (data.toString().includes('App running at')) {
          setTimeout(() => {
            mainWindow.loadURL('http://localhost:8080');
          }, 2000);
        }
      });
      
      frontendProcess.stderr.on('data', (data) => {
        console.error(`Frontend Error: ${data}`);
      });
    }
  }
  
  // 添加错误处理
  mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription) => {
    console.error(`Failed to load URL: ${errorDescription}`);
    // 如果加载失败，显示错误信息
    mainWindow.loadURL(`data:text/html,<html><body><h1>Failed to load content</h1><p>${errorDescription}</p><p>请确保前端服务正在运行</p></body></html>`);
  });
  
  // 添加页面加载完成的处理
  mainWindow.webContents.on('did-finish-load', () => {
    console.log('Page loaded successfully');
  });
};

// 应用准备就绪时创建窗口
app.whenReady().then(() => {
  createWindow();

  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

// 当所有窗口关闭时退出应用
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    if (backendProcess) {
      backendProcess.kill();
    }
    app.quit();
  }
});

// 应用退出时确保后端服务也被终止
app.on('before-quit', () => {
  if (backendProcess) {
    backendProcess.kill();
  }
});

// 添加应用退出处理
app.on('quit', () => {
  if (backendProcess) {
    backendProcess.kill();
  }
});